import random
import config.boxVacant as boxVacant


def calculate_image_positions_51_4(num_images, num_columns, num_rows, box_width=1080, box_height=1920, side_margin=40,
                                   top_bottom_margin=40, gap=40):
    """
    计算每个图像的位置和尺寸。

    参数:
        num_images (int): 图像的总数量。
        num_columns (int): 每行的图像数量。
        num_rows (int): 每列的图像数量。
        box_width (int): 盒子的宽度。
        box_height (int): 盒子的高度。
        side_margin (int): 左右间距。
        top_bottom_margin (int): 上下间距。
        gap (int): 图像之间的间隔大小。

    返回:
        list: 包含每个图像位置、尺寸和间隔大小的字典列表。
    """
    # 计算每个图像的最小尺寸
    available_width = box_width - 2 * side_margin - (num_columns - 1) * gap
    available_height = box_height - 2 * top_bottom_margin - (num_rows - 1) * gap
    min_dimension = min(available_width / num_columns, available_height / num_rows)

    # 生成相同尺寸的正方形
    square_sizes = [min_dimension] * num_images

    # 找到每个图像的尺寸和位置
    image_positions = []

    for i in range(num_images):
        # 计算当前图像所在的行和列
        row = i // num_columns
        col = i % num_columns

        # 计算图像左上角的坐标，考虑到边距和间隔
        x = col * (min_dimension + gap) + side_margin
        y = row * (min_dimension + gap) + top_bottom_margin

        # 添加当前图像的尺寸和位置到列表中
        image_positions.append({
            "position": (round(x), round(y)),
            "dimension": (round(square_sizes[i]), round(square_sizes[i])),
        })

    return image_positions


def calculate_image_positions_51_5(num_images, num_columns, num_rows, gap, box_width=1080, box_height=1920):
    """
    计算每个图像的位置和尺寸，以填满给定的空间。

    参数:
        num_images (int): 图像的总数量。
        num_columns (int): 每行的图像数量。
        num_rows (int): 每列的图像数量。
        gap (int): 图像之间的间隔大小。
        box_width (int): 盒子的宽度。
        box_height (int): 盒子的高度。

    返回:
        list: 包含每个图像位置、尺寸的字典列表。
    """
    # 计算每个图像的最小尺寸
    min_dimension = min(box_width / num_columns, box_height / num_rows)

    # 计算图像之间的实际间隔
    actual_gap_x = (box_width - min_dimension * num_columns) / (num_columns - 1)
    actual_gap_y = (box_height - min_dimension * num_rows) / (num_rows - 1)

    # 找到每个图像的尺寸和位置
    image_positions = []

    for i in range(num_images):
        # 计算当前图像所在的行和列
        row = i // num_columns
        col = i % num_columns

        # 计算图像左上角的坐标，考虑到间隔
        random_offset_x = random.uniform(-40, 40)
        random_offset_y = random.uniform(-40, 40)
        x = col * (min_dimension + actual_gap_x) + random_offset_x
        y = row * (min_dimension + actual_gap_y) + random_offset_y

        # 添加当前图像的尺寸和位置到列表中
        image_positions.append({
            "position": (round(x), round(y)),
            "dimension": (round(min_dimension), round(min_dimension)),
        })

        # 调整第一排图像的位置，向下移动 80 个单位
    for i in range(num_columns):
        image_positions[i]["position"] = (image_positions[i]["position"][0], image_positions[i]["position"][1] + 80)

        # 调整最后一排图像的位置，向上移动 65 个单位
    for i in range(num_images - num_columns, num_images):
        image_positions[i]["position"] = (image_positions[i]["position"][0], image_positions[i]["position"][1] - 80)

    image_positions.append({
        "position": (image_positions[5]['position'][0], image_positions[5]['position'][1] + 100),
        "dimension": (round(image_positions[5]['dimension'][0] * 2), round(image_positions[5]['dimension'][0] * 2)),
    })
    indices_to_remove = [5, 6, 9, 10]
    for index in sorted(indices_to_remove, reverse=True):
        del image_positions[index]
    return image_positions



def calculate_image_positions_51_7(num_images, box_width=1080, box_height=1920):
    # num_columns = 4
    # num_rows = 5
    #
    # # 有效高度范围在中间80%
    # effective_height_start = int(box_height * 0.1)
    # effective_height_end = int(box_height * 0.9)
    # effective_height = effective_height_end - effective_height_start
    #
    # # 计算每个网格单元的尺寸
    # cell_width = box_width // num_columns
    # cell_height = effective_height // num_rows
    #
    # # 初始化一个数组来存储每个盒子的大小和位置
    # boxes = []
    #
    # for i in range(num_images):
    #     # 计算当前图像所在的行和列
    #     row = i // num_columns
    #     col = i % num_columns
    #
    #     # 计算网格单元的起始位置
    #     cell_x = col * cell_width
    #     cell_y = effective_height_start + (row * cell_height)
    #
    #     # 随机生成图像大小，但不超过单元格的尺寸，可以增加一个放大因子
    #     size_factor = random.uniform(1, 1.4)  # 调整这个范围以控制放大程度
    #     size = int(min(cell_width, cell_height) * size_factor)
    #
    #     # 确保图像在单元格内居中
    #     x = cell_x + (cell_width - size) // 2
    #     y = cell_y + (cell_height - size) // 2
    #
    #     # 存储图像的大小和位置
    #     boxes.append({'dimension': (size, size), 'position': (x, y)})
    boxes = [
        {'dimension': (305, 305), 'position': (0, 179)},
        {'dimension': (200, 200), 'position': (313, 239)},
        {'dimension': (335, 335), 'position': (522, 173)},
        {'dimension': (240, 240), 'position': (846, 156)},

        {'dimension': (330, 330), 'position': (0, 492)},
        {'dimension': (150, 150), 'position': (321, 499)},
        {'dimension': (270, 270), 'position': (488, 506)},
        {'dimension': (330, 330), 'position': (790, 457)},

        {'dimension': (254, 254), 'position': (0, 827)},
        {'dimension': (264, 264), 'position': (238, 802)},
        {'dimension': (275, 275), 'position': (492, 797)},
        {'dimension': (286, 286), 'position': (787, 801)},

        {'dimension': (160, 160), 'position': (30, 1101)},
        {'dimension': (250, 250), 'position': (236, 1078)},
        {'dimension': (259, 259), 'position': (550, 1122)},
        {'dimension': (327, 327), 'position': (776, 1078)},

        {'dimension': (279, 279), 'position': (0, 1414)},
        {'dimension': (214, 214), 'position': (283, 1431)},
        {'dimension': (345, 345), 'position': (502, 1401)},
        {'dimension': (242, 242), 'position': (825, 1436)}]
    return boxes



if __name__ == '__main__':
    # 设置盒子尺寸、图像数量和边距
    box_width = 1080
    box_height = 1920
    num_images = 20
    num_columns = 4  # 每行的图像数量
    num_rows = 5  # 每列的图像数量

    # 计算图像尺寸和位置
    image_positions = calculate_image_positions_51_7(num_images, box_width, box_height)

    # 打印图像尺寸、位置和间隔大小
    for i, info in enumerate(image_positions):
        print(f"图像 {i + 1}: 位置 {info['position']}, 尺寸 {info['dimension']}")
